const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const router = express.Router();
const { authenticateToken, requireRole } = require('../middleware/auth');

// 定义材料类型到目录的映射
const materialTypeToDir = {
  lecture: 'materials',
  slides: 'materials', 
  docx: 'docx',
  pptx: 'pptx',
  video: 'videos',
  examples: 'samples',
  practice: 'tasks',
  assignment: 'homeworks'
};

// 确保目录存在
const ensureDirectoryExists = (dirPath) => {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
  }
};

// 配置multer存储 - 使用临时目录
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    // 使用临时目录存储文件
    const tempPath = path.join(__dirname, '../temp');
    ensureDirectoryExists(tempPath);
    cb(null, tempPath);
  },
  filename: (req, file, cb) => {
    // 正确处理中文文件名编码
    const originalname = Buffer.from(file.originalname, 'latin1').toString('utf8');
    const timestamp = Date.now();
    const ext = path.extname(originalname);
    const name = path.basename(originalname, ext);
    cb(null, `${name}_${timestamp}${ext}`);
  }
});

// 文件过滤器
const fileFilter = (req, file, cb) => {
  // 在fileFilter阶段，req.body可能还未完全解析
  // 我们先允许所有文件通过，在路由处理器中进行验证
  cb(null, true);
};

// 文件类型验证函数
const validateFileType = (materialType, filename) => {
  const allowedTypes = {
    lecture: ['.doc', '.docx', '.md', '.pdf'],
    slides: ['.pptx', '.pdf'],
    docx: ['.doc', '.docx'],
    pptx: ['.pptx', '.pdf'],
    video: ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm'],
    examples: ['.html', '.css', '.js', '.vue', '.zip', '.rar'],
    practice: ['.html', '.css', '.js', '.vue', '.zip', '.rar', '.md'],
    assignment: ['.pdf', '.doc', '.docx', '.md', '.txt']
  };
  
  const ext = path.extname(filename).toLowerCase();
  
  if (!allowedTypes[materialType]) {
    return `不支持的材料类型: ${materialType}`;
  }
  
  if (!allowedTypes[materialType].includes(ext)) {
    return `${materialType}类型不支持${ext}格式的文件`;
  }
  
  return null; // 验证通过
};

const upload = multer({ 
  storage,
  fileFilter,
  limits: {
    fileSize: 100 * 1024 * 1024 // 100MB限制
  }
});

// 上传单个文件
router.post('/upload', authenticateToken, requireRole(['admin', 'teacher']), upload.single('file'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({
        success: false,
        message: '没有上传文件'
      });
    }
    
    const { chapterNumber, materialType } = req.body;
    
    // 验证必需参数
    if (!chapterNumber || !materialType) {
      fs.unlinkSync(req.file.path);
      return res.status(400).json({
        success: false,
        message: '章节号和材料类型是必需的'
      });
    }
    
    if (!materialTypeToDir[materialType]) {
      fs.unlinkSync(req.file.path);
      return res.status(400).json({
        success: false,
        message: '无效的材料类型'
      });
    }
    
    // 验证文件类型 - 使用正确编码的文件名
    const originalName = Buffer.from(req.file.originalname, 'latin1').toString('utf8');
    const validationError = validateFileType(materialType, originalName);
    if (validationError) {
      // 删除已上传的文件
      fs.unlinkSync(req.file.path);
      return res.status(400).json({
        success: false,
        message: validationError
      });
    }
    
    const chapterDir = `chap${String(chapterNumber).padStart(2, '0')}`;
    const materialDir = materialTypeToDir[materialType];
    
    // 构建目标路径
    const targetDir = path.join(
      __dirname, 
      '../../vue-lab-project/public',
      chapterDir,
      materialDir
    );
    
    // 确保目标目录存在
    ensureDirectoryExists(targetDir);
    
    // 构建目标文件路径
    const targetPath = path.join(targetDir, req.file.filename);
    
    // 移动文件从临时目录到目标目录
    fs.renameSync(req.file.path, targetPath);
    
    // 构建相对于public目录的URL路径
    const fileUrl = `/${chapterDir}/${materialDir}/${req.file.filename}`;
    
    // 构建章节相对路径（用于保存到数据库）
    const relativePath = `${chapterDir}\\${materialDir}\\${req.file.filename}`;
    
    // originalName已在文件类型验证时处理过编码
    
    res.json({
      success: true,
      message: '文件上传成功',
      data: {
        filename: req.file.filename,
        originalName: originalName,
        size: req.file.size,
        url: fileUrl,
        path: relativePath
      }
    });
  } catch (error) {
    console.error('文件上传错误:', error);
    // 清理临时文件
    if (req.file && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    res.status(500).json({
      success: false,
      message: '文件上传失败',
      error: error.message
    });
  }
});

// 上传多个文件
router.post('/upload-multiple', authenticateToken, requireRole(['admin', 'teacher']), upload.array('files', 10), (req, res) => {
  try {
    if (!req.files || req.files.length === 0) {
      return res.status(400).json({
        success: false,
        message: '没有上传文件'
      });
    }
    
    const { chapterNumber, materialType } = req.body;
    
    // 验证必需参数
    if (!chapterNumber || !materialType) {
      // 删除所有已上传的文件
      req.files.forEach(f => {
        try {
          fs.unlinkSync(f.path);
        } catch (err) {
          console.error('删除文件失败:', err);
        }
      });
      return res.status(400).json({
        success: false,
        message: '章节号和材料类型是必需的'
      });
    }
    
    if (!materialTypeToDir[materialType]) {
      // 删除所有已上传的文件
      req.files.forEach(f => {
        try {
          fs.unlinkSync(f.path);
        } catch (err) {
          console.error('删除文件失败:', err);
        }
      });
      return res.status(400).json({
        success: false,
        message: '无效的材料类型'
      });
    }
    
    // 验证所有文件类型 - 使用正确编码的文件名
    for (const file of req.files) {
      const originalName = Buffer.from(file.originalname, 'latin1').toString('utf8');
      const validationError = validateFileType(materialType, originalName);
      if (validationError) {
        // 删除所有已上传的文件
        req.files.forEach(f => {
          try {
            fs.unlinkSync(f.path);
          } catch (err) {
            console.error('删除文件失败:', err);
          }
        });
        return res.status(400).json({
          success: false,
          message: `文件 ${originalName}: ${validationError}`
        });
      }
    }
    
    const chapterDir = `chap${String(chapterNumber).padStart(2, '0')}`;
    const materialDir = materialTypeToDir[materialType];
    
    // 构建目标路径
    const targetDir = path.join(
      __dirname, 
      '../../vue-lab-project/public',
      chapterDir,
      materialDir
    );
    
    // 确保目标目录存在
    ensureDirectoryExists(targetDir);
    
    const uploadedFiles = req.files.map(file => {
      // 构建目标文件路径
      const targetPath = path.join(targetDir, file.filename);
      
      // 移动文件从临时目录到目标目录
      fs.renameSync(file.path, targetPath);
      
      // 正确处理原始文件名编码
      const originalName = Buffer.from(file.originalname, 'latin1').toString('utf8');
      
      const fileUrl = `/${chapterDir}/${materialDir}/${file.filename}`;
      
      // 构建章节相对路径（用于保存到数据库）
      const relativePath = `${chapterDir}\\${materialDir}\\${file.filename}`;
      
      return {
        filename: file.filename,
        originalName: originalName,
        size: file.size,
        url: fileUrl,
        path: relativePath
      };
    });
    
    res.json({
      success: true,
      message: `成功上传${uploadedFiles.length}个文件`,
      data: uploadedFiles
    });
  } catch (error) {
    console.error('批量文件上传错误:', error);
    // 清理临时文件
    if (req.files) {
      req.files.forEach(f => {
        try {
          if (fs.existsSync(f.path)) {
            fs.unlinkSync(f.path);
          }
        } catch (err) {
          console.error('删除临时文件失败:', err);
        }
      });
    }
    res.status(500).json({
      success: false,
      message: '批量文件上传失败',
      error: error.message
    });
  }
});

// 获取章节文件列表
router.get('/files/:chapterNumber/:materialType', authenticateToken, (req, res) => {
  try {
    const { chapterNumber, materialType } = req.params;
    
    if (!materialTypeToDir[materialType]) {
      return res.status(400).json({
        success: false,
        message: '无效的材料类型'
      });
    }
    
    const chapterDir = `chap${String(chapterNumber).padStart(2, '0')}`;
    const materialDir = materialTypeToDir[materialType];
    
    const dirPath = path.join(
      __dirname,
      '../../vue-lab-project/public',
      chapterDir,
      materialDir
    );
    
    if (!fs.existsSync(dirPath)) {
      return res.json({
        success: true,
        data: []
      });
    }
    
    const files = fs.readdirSync(dirPath).map(filename => {
      const filePath = path.join(dirPath, filename);
      const stats = fs.statSync(filePath);
      const fileUrl = `/${chapterDir}/${materialDir}/${filename}`;
      
      // 从文件名中提取原始名称（去掉时间戳前缀）
      const originalName = filename.replace(/^\d{13}-/, '');
      
      return {
        filename,
        originalName,
        url: fileUrl,
        size: stats.size,
        path: filePath,
        createdAt: stats.birthtime,
        modifiedAt: stats.mtime
      };
    });
    
    res.json({
      success: true,
      data: files
    });
  } catch (error) {
    console.error('获取文件列表错误:', error);
    res.status(500).json({
      success: false,
      message: '获取文件列表失败',
      error: error.message
    });
  }
});

// 删除文件
router.delete('/files/:chapterNumber/:materialType/:filename', authenticateToken, requireRole(['admin', 'teacher']), (req, res) => {
  try {
    const { chapterNumber, materialType, filename } = req.params;
    
    if (!materialTypeToDir[materialType]) {
      return res.status(400).json({
        success: false,
        message: '无效的材料类型'
      });
    }
    
    const chapterDir = `chap${String(chapterNumber).padStart(2, '0')}`;
    const materialDir = materialTypeToDir[materialType];
    
    const filePath = path.join(
      __dirname,
      '../../vue-lab-project/public',
      chapterDir,
      materialDir,
      filename
    );
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({
        success: false,
        message: '文件不存在'
      });
    }
    
    fs.unlinkSync(filePath);
    
    res.json({
      success: true,
      message: '文件删除成功'
    });
  } catch (error) {
    console.error('删除文件错误:', error);
    res.status(500).json({
      success: false,
      message: '删除文件失败',
      error: error.message
    });
  }
});

module.exports = router;